
<!DOCTYPE html>

<html lang="en">
  <head>
    <meta charset="utf-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" /><meta name="generator" content="Docutils 0.17.1: http://docutils.sourceforge.net/" />

    <title>Leo and Emacs, including org mode &#8212; Leo 6.7.2 documentation</title>
    <link rel="stylesheet" type="text/css" href="_static/pygments.css" />
    <link rel="stylesheet" type="text/css" href="_static/classic.css" />
    <link rel="stylesheet" type="text/css" href="_static/custom.css" />
    
    <script data-url_root="./" id="documentation_options" src="_static/documentation_options.js"></script>
    <script src="_static/jquery.js"></script>
    <script src="_static/underscore.js"></script>
    <script src="_static/_sphinx_javascript_frameworks_compat.js"></script>
    <script src="_static/doctools.js"></script>
    <script src="_static/sphinx_highlight.js"></script>
    
    <script src="_static/sidebar.js"></script>
    
    <link rel="index" title="Index" href="genindex.html" />
    <link rel="search" title="Search" href="search.html" />
    <link rel="next" title="Using Vim with Leo" href="vimBindings.html" />
    <link rel="prev" title="Leo and Asciidoctor" href="leoandasciidoc.html" /> 
  </head><body>
    <div class="related" role="navigation" aria-label="related navigation">
      <h3>Navigation</h3>
      <ul>
        <li class="right" style="margin-right: 10px">
          <a href="genindex.html" title="General Index"
             accesskey="I">index</a></li>
        <li class="right" >
          <a href="vimBindings.html" title="Using Vim with Leo"
             accesskey="N">next</a> |</li>
        <li class="right" >
          <a href="leoandasciidoc.html" title="Leo and Asciidoctor"
             accesskey="P">previous</a> |</li>
        <li class="nav-item nav-item-0"><a href="leo_toc.html">Leo 6.7.2 documentation</a> &#187;</li>
          <li class="nav-item nav-item-1"><a href="leoandotherprograms.html" accesskey="U">Leo and Other Programs</a> &#187;</li>
        <li class="nav-item nav-item-this"><a href="">Leo and Emacs, including org mode</a></li> 
      </ul>
    </div>  

    <div class="document">
      <div class="documentwrapper">
        <div class="bodywrapper">
          <div class="body" role="main">
            
  <section id="leo-and-emacs-including-org-mode">
<h1>Leo and Emacs, including org mode<a class="headerlink" href="#leo-and-emacs-including-org-mode" title="Permalink to this heading">¶</a></h1>
<p>This chapter several topics relating to the Emacs editor.</p>
<div class="contents local topic" id="contents">
<p class="topic-title">Contents</p>
<ul class="simple">
<li><p><a class="reference internal" href="#leo-vs-org-mode" id="id1">Leo vs org mode</a></p></li>
<li><p><a class="reference internal" href="#using-org-mode-org-files-in-leo" id="id2">Using org-mode (.org) files in Leo</a></p></li>
<li><p><a class="reference internal" href="#controlling-leo-from-emacs-using-pymacs" id="id3">Controlling Leo from Emacs using Pymacs</a></p></li>
<li><p><a class="reference internal" href="#functions-in-leopymacs-py" id="id4">Functions in leoPymacs.py</a></p></li>
<li><p><a class="reference internal" href="#the-minibuffer" id="id5">The minibuffer</a></p></li>
</ul>
</div>
<section id="leo-vs-org-mode">
<h2><a class="toc-backref" href="#id1">Leo vs org mode</a><a class="headerlink" href="#leo-vs-org-mode" title="Permalink to this heading">¶</a></h2>
<p>Leo and <a class="reference external" href="http://orgmode.org/">Emacs org mode</a> share similar goals. Org mode has many strengths related to non-programming tasks:</p>
<ul class="simple">
<li><p>Drawers: visible, pure text, easily extensible uA’s.</p></li>
<li><p>Agendas and tables.</p></li>
<li><p>In-pane rendering of Latex and special symbols.</p></li>
<li><p>Support for multiple source languages, including shell scripts, C, etc.</p></li>
<li><p>Code blocks, with arguments.</p></li>
<li><p>Result blocks.</p></li>
</ul>
<p>But org mode is unsuitable for software development. Org mode’s code block syntax:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="c1">#+NAME: &lt;name&gt;</span>
<span class="c1">#+BEGIN_SRC &lt;language&gt; &lt;switches&gt; &lt;header arguments&gt;</span>
    <span class="o">&lt;</span><span class="n">body</span><span class="o">&gt;</span>
<span class="c1">#+END_SRC</span>
</pre></div>
</div>
<p>would be unbearable in source files.</p>
<p>More generally, org mode lacks the following Leonine features:</p>
<ul class="simple">
<li><p>Automatic tangling when saving files.</p></li>
<li><p>Automatic untangling when loading files.</p></li>
<li><p>&#64;others</p></li>
<li><p>Importers for programming languages.</p></li>
<li><p>Clones and especially Leo’s clone-find commands.</p></li>
<li><p>A full Python API and DOM, including generators.</p></li>
<li><p>&#64;command, &#64;button.</p></li>
</ul>
<p>Leo’s is based on technologies missing from org mode:</p>
<ul class="simple">
<li><p>Clones require that outlines be <a class="reference external" href="https://en.wikipedia.org/wiki/Directed_acyclic_graph">Directed Acyclic Graphs</a>.</p></li>
<li><p>Leo updates &#64;clean trees using an <a class="reference external" href="appendices.html#the-mulder-ream-update-algorithm">algorithm</a> that could not be duplicated in org mode.</p></li>
<li><p>Leo’s outlines are true Python objects, with unique, persistent identities.</p></li>
</ul>
<p>In contrast, org mode is completely text oriented:</p>
<ul class="simple">
<li><p>Org mode’s API is limited to parsing body text.</p></li>
<li><p>Org mode simulates a DOM with text filters.</p></li>
</ul>
</section>
<section id="using-org-mode-org-files-in-leo">
<h2><a class="toc-backref" href="#id2">Using org-mode (.org) files in Leo</a><a class="headerlink" href="#using-org-mode-org-files-in-leo" title="Permalink to this heading">¶</a></h2>
<p>Leo can automatically import and export Emacs org-mode (.org) files. Nodes like:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="nd">@auto</span><span class="o">-</span><span class="n">org</span><span class="o">-</span><span class="n">mode</span> <span class="o">&lt;</span><span class="n">path</span> <span class="n">to</span> <span class="o">.</span><span class="n">org</span> <span class="n">file</span><span class="o">&gt;</span>
</pre></div>
</div>
<p>or equivalently:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="nd">@auto</span><span class="o">-</span><span class="n">org</span> <span class="o">&lt;</span><span class="n">path</span> <span class="n">to</span> <span class="o">.</span><span class="n">org</span> <span class="n">file</span><span class="o">&gt;</span>
</pre></div>
</div>
<p>import the org-mode file as a Leo outline.</p>
<p>These nodes work like other &#64;auto nodes: when Leo loads an outline, Leo reads the .org file into the &#64;auto-org-mode tree. When Leo writes an outline, Leo writes any &#64;auto-org-mode tree back to the org-mode file.</p>
<p>After creating an &#64;auto-org-mode node by hand, be sure to use Leo’s refresh-from-disk command to populate the node. Do this <em>before</em> saving the .leo file. If you try to save an empty &#64;auto-org-mode node Leo will warn you that you are about to overwrite the file.</p>
<p>The <code class="docutils literal notranslate"><span class="pre">refresh-from-disk</span></code> command creates an &#64;auto-org-mode node whose <strong>children</strong> represent the contents of the external .org file. Leo does <em>not</em> write the &#64;auto-org-mode node itself. This allows you to put Leo directives in the node.</p>
</section>
<section id="controlling-leo-from-emacs-using-pymacs">
<h2><a class="toc-backref" href="#id3">Controlling Leo from Emacs using Pymacs</a><a class="headerlink" href="#controlling-leo-from-emacs-using-pymacs" title="Permalink to this heading">¶</a></h2>
<p>Leo’s leoPymacs module is a simple ‘server’ for the <a class="reference external" href="http://pymacs.progiciels-bpi.ca/index.html">pymacs</a> package. Using pymacs and leoPymacs, <a class="reference external" href="http://en.wikipedia.org/wiki/Emacs_Lisp">elisp</a> scripts in <a class="reference external" href="http://www.xemacs.org/">Emacs</a> can open .leo files and execute <em>Python</em> scripts as if they were executed inside Leo. In particular, such scripts can use Leo’s predefined c, g and p variables. Thus, <em>Python</em> scripts running in Emacs can:</p>
<ul class="simple">
<li><p>Open any .leo file.</p></li>
<li><p>Access any part of the outline.</p></li>
<li><p>Change any part of the outline, including external files,</p></li>
<li><p>Save .leo files.</p></li>
<li><p>Execute <em>any</em> Leo script.</p></li>
</ul>
<p>In short, you can now do from Emacs anything that you can do with Leo scripting inside Leo.</p>
<p>Here are step-by-step instructions for executing Python scripts in Emacs:</p>
<p><strong>Step 1. Install pymacs</strong></p>
<blockquote>
<div><p>The pymacs installation instructions should be clear enough.
A clarification is needed about two-way communication between Python and lisp scripts:
in truth, Python scripts can call the Pymacs.lisp function <em>only</em> if the Python script
was invoked from emacs.
Otherwise, calling Pymacs.lisp will hang the process making the call.
For example, executing the following script as an ordinary Leo script will hang Leo:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="kn">from</span> <span class="nn">Pymacs</span> <span class="kn">import</span> <span class="n">lisp</span>
<span class="nb">print</span> <span class="n">lisp</span><span class="p">(</span><span class="s2">&quot;&quot;&quot;2+2&quot;&quot;&quot;</span><span class="p">)</span> <span class="c1"># Hangs</span>
</pre></div>
</div>
</div></blockquote>
<p><strong>Step 2. Load the leoPymacs module from Emacs, creating a hidden Leo application</strong></p>
<blockquote>
<div><p>From inside Emacs, you load Leo’s leoPymacs module as follows:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">(</span><span class="n">pymacs</span><span class="o">-</span><span class="n">load</span> <span class="s2">&quot;leoPymacs&quot;</span> <span class="s2">&quot;leo-&quot;</span><span class="p">)</span>
</pre></div>
</div>
<p>The call to pymacs-load is similar to ‘import leoPymacs as leo-’ in
Python. The side effect of pymacs-load is to define the elisp
function leo-x for every top-level function x in leoPymacs.py,
namely leo-dump, leo-get-app, leo-get-g, leo-get-script-result,
leo-init, leo-open and leo-run-script. The first call to any of
these functions creates a <strong>hidden Leo application</strong> in which .leo
files may be loaded, modified and saved, and in which Leo scripts
may be executed. This hidden Leo application uses Leo’s nullGui
class as its gui, so Leo commands and Leo scripts that require a
fully functional gui will not work as expected in the hidden Leo
application. Steps 3 and 4 tell how to use this hidden Leo
application.</p>
<p>pymacs-load works like a Python reload, so you can redefine
leoPymacs.py while Emacs is running. However, calling pymacs-load
destroys the old hidden Leo application and creates a new one, so
typically you would want to call pymacs-load only once per Emacs
session. Like this:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">(</span><span class="n">setq</span> <span class="n">reload</span> <span class="n">nil</span><span class="p">)</span> <span class="p">;</span> <span class="n">change</span> <span class="n">nil</span> <span class="n">to</span> <span class="n">t</span> <span class="n">to</span> <span class="n">force</span> <span class="n">a</span> <span class="n">reload</span><span class="o">.</span>

<span class="p">(</span><span class="k">if</span> <span class="p">(</span><span class="ow">or</span> <span class="n">reload</span> <span class="p">(</span><span class="ow">not</span> <span class="p">(</span><span class="n">boundp</span> <span class="s1">&#39;leoPymacs)))</span>
    <span class="p">(</span><span class="n">setq</span> <span class="n">leoPymacs</span> <span class="p">(</span><span class="n">pymacs</span><span class="o">-</span><span class="n">load</span> <span class="s2">&quot;leoPymacs&quot;</span> <span class="s2">&quot;leo-&quot;</span><span class="p">))</span>
    <span class="p">(</span><span class="n">message</span> <span class="s2">&quot;leoPymacs already loaded&quot;</span><span class="p">)</span>
<span class="p">)</span>
</pre></div>
</div>
</div></blockquote>
<p><strong>Step 3. From Emacs, open .leo files</strong></p>
<blockquote>
<div><p>Once we have loaded the leoPymacs module
we can open a .leo file as follows:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">(</span><span class="n">setq</span> <span class="n">c</span> <span class="p">(</span><span class="n">leo</span><span class="o">-</span><span class="nb">open</span> <span class="n">fileName</span><span class="p">))</span>
</pre></div>
</div>
<p>This binds the elisp c variable to the Leo commander created by opening fileName.
fileName should be the full path to a .leo file.
In the next step we will use this c variable to execute <em>Leo</em> scripts in the
context of an open Leo outline.</p>
<p>Sometimes we want to execute a Leo script before opening any Leo commanders.
For example, we might want to compute the fileName passed to leo-open.
leo-run-script allows the c argument to be nil,
in which case leo-run-script creates a dummy commander in which to run the script.
For example, the following script calls g.os_path_join and g.os_path_abspath:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">(</span><span class="n">setq</span> <span class="n">script</span> <span class="s2">&quot;g.app.scriptResult =</span>
    <span class="n">g</span><span class="o">.</span><span class="n">os_path_abspath</span><span class="p">(</span><span class="n">g</span><span class="o">.</span><span class="n">os_path_join</span><span class="p">(</span>
        <span class="n">g</span><span class="o">.</span><span class="n">app</span><span class="o">.</span><span class="n">loadDir</span><span class="p">,</span><span class="s1">&#39;..&#39;</span><span class="p">,</span><span class="s1">&#39;test&#39;</span><span class="p">,</span><span class="s1">&#39;ut.leo&#39;</span><span class="p">))</span><span class="s2">&quot;</span>
<span class="p">)</span>

<span class="p">(</span><span class="n">setq</span> <span class="n">fileName</span> <span class="p">(</span><span class="n">leo</span><span class="o">-</span><span class="n">run</span><span class="o">-</span><span class="n">script</span> <span class="n">nil</span> <span class="n">script</span><span class="p">))</span>
</pre></div>
</div>
<p>leo-run-script returns the value of g.app.scriptResult
As shown above, Python scripts may set g.app.scriptResult to indicate their result.
elisp scripts can also get g.app.scriptResult using leo-script-result.
Note that the Python script may span multiple lines.</p>
</div></blockquote>
<p><strong>Step 4. From Emacs, execute Leo (Python) scripts</strong></p>
<blockquote>
<div><p>From emacs we can execute a Python script <strong>as if</strong> it were executed in an
open Leo outline.
Suppose aLeoScript is an <strong>elisp</strong> string containing a Leo (Python) script.
We can execute that script in the hidden Leo application as follows:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">(</span><span class="n">leo</span><span class="o">-</span><span class="n">run</span><span class="o">-</span><span class="n">script</span> <span class="n">c</span> <span class="n">aLeoScript</span><span class="p">)</span>
</pre></div>
</div>
<p>For example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">(</span><span class="n">setq</span> <span class="n">c</span> <span class="p">(</span><span class="n">leo</span><span class="o">-</span><span class="nb">open</span> <span class="n">fileName</span><span class="p">)</span>
<span class="p">(</span><span class="n">csetq</span> <span class="n">script</span> <span class="s2">&quot;print &#39;c&#39;,c,&#39;h&#39;,c.p.h&quot;</span><span class="p">)</span>
<span class="p">(</span><span class="n">leo</span><span class="o">-</span><span class="n">run</span><span class="o">-</span><span class="n">script</span> <span class="n">c</span> <span class="n">script</span><span class="p">)</span>
</pre></div>
</div>
</div></blockquote>
<p>Putting this all together, we get:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">;</span> <span class="n">Step</span> <span class="mi">1</span><span class="p">:</span> <span class="n">load</span> <span class="n">leoPymacs</span> <span class="k">if</span> <span class="n">it</span> <span class="n">has</span> <span class="ow">not</span> <span class="n">already</span> <span class="n">been</span> <span class="n">loaded</span><span class="o">.</span>
<span class="p">(</span><span class="n">setq</span> <span class="n">reload</span> <span class="n">nil</span><span class="p">)</span>
<span class="p">(</span><span class="k">if</span> <span class="p">(</span><span class="ow">or</span> <span class="n">reload</span> <span class="p">(</span><span class="ow">not</span> <span class="p">(</span><span class="n">boundp</span> <span class="s1">&#39;leoPymacs)))</span>
    <span class="p">(</span><span class="n">setq</span> <span class="n">leoPymacs</span> <span class="p">(</span><span class="n">pymacs</span><span class="o">-</span><span class="n">load</span> <span class="s2">&quot;leoPymacs&quot;</span> <span class="s2">&quot;leo-&quot;</span><span class="p">))</span>
    <span class="p">(</span><span class="n">message</span> <span class="s2">&quot;leoPymacs already loaded&quot;</span><span class="p">)</span>
<span class="p">)</span>

<span class="p">;</span> <span class="n">Step</span> <span class="mi">2</span><span class="p">:</span> <span class="n">compute</span> <span class="n">the</span> <span class="n">path</span> <span class="n">to</span> <span class="n">leo</span><span class="o">/</span><span class="n">test</span><span class="o">/</span><span class="n">ut</span><span class="o">.</span><span class="n">leo</span> <span class="n">using</span> <span class="n">a</span> <span class="n">Leo</span> <span class="n">script</span><span class="o">.</span>
<span class="p">(</span><span class="n">setq</span> <span class="n">script</span>
    <span class="s2">&quot;g.app.scriptResult = g.os_path_abspath(</span>
        <span class="n">g</span><span class="o">.</span><span class="n">os_path_join</span><span class="p">(</span><span class="n">g</span><span class="o">.</span><span class="n">app</span><span class="o">.</span><span class="n">loadDir</span><span class="p">,</span><span class="s1">&#39;..&#39;</span><span class="p">,</span><span class="s1">&#39;test&#39;</span><span class="p">,</span><span class="s1">&#39;ut.leo&#39;</span><span class="p">))</span><span class="s2">&quot;</span>
<span class="p">)</span>
<span class="p">(</span><span class="n">setq</span> <span class="n">fileName</span> <span class="p">(</span><span class="n">leo</span><span class="o">-</span><span class="n">run</span><span class="o">-</span><span class="n">script</span> <span class="n">nil</span> <span class="n">script</span><span class="p">))</span>

<span class="p">;</span> <span class="n">Step</span> <span class="mi">3</span><span class="p">:</span> <span class="n">execute</span> <span class="n">a</span> <span class="n">script</span> <span class="ow">in</span> <span class="n">ut</span><span class="o">.</span><span class="n">leo</span><span class="o">.</span>
<span class="p">(</span><span class="n">setq</span> <span class="n">c</span> <span class="p">(</span><span class="n">leo</span><span class="o">-</span><span class="nb">open</span> <span class="n">fileName</span><span class="p">))</span>
<span class="p">(</span><span class="n">setq</span> <span class="n">script</span> <span class="s2">&quot;print &#39;c&#39;,c.shortFileName() ,&#39;current:&#39;,c.p.h&quot;</span><span class="p">)</span>
<span class="p">(</span><span class="n">leo</span><span class="o">-</span><span class="n">run</span><span class="o">-</span><span class="n">script</span> <span class="n">c</span> <span class="n">script</span><span class="p">)</span>
</pre></div>
</div>
</section>
<section id="functions-in-leopymacs-py">
<h2><a class="toc-backref" href="#id4">Functions in leoPymacs.py</a><a class="headerlink" href="#functions-in-leopymacs-py" title="Permalink to this heading">¶</a></h2>
<p>The leoPymacs module is intended to be called from Emacs using pymacs.  It contains the following top-level functions:</p>
<ul>
<li><p>get_app()</p>
<p>Returns the hidden app created by the leoPymacs.init function.</p>
</li>
<li><p>dump(anyPythonObject)</p>
<p>Returns str(repr(anyPythonObject)).</p>
</li>
<li><p>get_g()</p>
<p>Returns the leoGlobals module of the hidden app created by the leoPymacs.init function.</p>
</li>
<li><p>get_script_result()</p>
<p>Returns g.app.scriptResult, where g.app is the hidden app.</p>
</li>
<li><p>init()
Calls leo.run(pymacs=True) to create a hidden Leo application.
Later calls to open can open hidden Leo outlines that can be accessed via runScript.</p></li>
<li><p>open(fileName)</p>
<p>Opens the .leo file given by fileName. fileName must be the full
path to a .leo file. Returns the commander of the open Leo outline,
or None if the outline could not be opened.</p>
</li>
<li><p>run_script(c,script,p=None)</p>
<p>Executes a script in the context of a commander c returned by the leoPymacs.open.
c may be None, in which case a dummy commander is created in which to run the script.
In the executed script, p is set to c.p if no p argument is specified.
Returns g.app.scriptResult, where g.app is the hidden app.</p>
</li>
</ul>
</section>
<section id="the-minibuffer">
<h2><a class="toc-backref" href="#id5">The minibuffer</a><a class="headerlink" href="#the-minibuffer" title="Permalink to this heading">¶</a></h2>
<p>Leo’s mini-buffer is a text area at the bottom of the body pane. You use Leo’s minibuffer like the Emacs mini-buffer to invoke commands by their so-called <em>long name</em>. The following commands affect the minibuffer:</p>
<ul class="simple">
<li><p><strong>full-command</strong>: (default shortcut: Alt-x) Puts the focus in the minibuffer. Type a full command name, then hit &lt;Return&gt; to execute the command. Tab completion works, but not yet for file names.</p></li>
<li><p><strong>quick-command-mode</strong>: (default shortcut: Alt-x) Like Emacs Control-C. This mode is defined in leoSettings.leo. It is useful for commonly-used commands.</p></li>
<li><p><strong>universal-argument</strong>: (default shortcut: Alt-u) Like Emacs Ctrl-u. Adds a repeat count for later command. Ctrl-u 999 a adds 999 a’s.</p></li>
<li><p><strong>keyboard-quit</strong>: (default shortcut: Ctrl-g) Exits any minibuffer mode and puts the focus in the body pane.</p></li>
</ul>
<p>For example, to print a list of all commands type Alt-X print-commands &lt;Return&gt;.</p>
</section>
</section>


            <div class="clearer"></div>
          </div>
        </div>
      </div>
      <div class="sphinxsidebar" role="navigation" aria-label="main navigation">
        <div class="sphinxsidebarwrapper">
            <p class="logo"><a href="leo_toc.html">
              <img class="logo" src="_static/LeoLogo.svg" alt="Logo"/>
            </a></p>
  <div>
    <h4>Previous topic</h4>
    <p class="topless"><a href="leoandasciidoc.html"
                          title="previous chapter">Leo and Asciidoctor</a></p>
  </div>
  <div>
    <h4>Next topic</h4>
    <p class="topless"><a href="vimBindings.html"
                          title="next chapter">Using Vim with Leo</a></p>
  </div>
<div id="searchbox" style="display: none" role="search">
  <h3 id="searchlabel">Quick search</h3>
    <div class="searchformwrapper">
    <form class="search" action="search.html" method="get">
      <input type="text" name="q" aria-labelledby="searchlabel" autocomplete="off" autocorrect="off" autocapitalize="off" spellcheck="false"/>
      <input type="submit" value="Go" />
    </form>
    </div>
</div>
<script>document.getElementById('searchbox').style.display = "block"</script>
        </div>
<div id="sidebarbutton" title="Collapse sidebar">
<span>«</span>
</div>

      </div>
      <div class="clearer"></div>
    </div>
    <div class="related" role="navigation" aria-label="related navigation">
      <h3>Navigation</h3>
      <ul>
        <li class="right" style="margin-right: 10px">
          <a href="genindex.html" title="General Index"
             >index</a></li>
        <li class="right" >
          <a href="vimBindings.html" title="Using Vim with Leo"
             >next</a> |</li>
        <li class="right" >
          <a href="leoandasciidoc.html" title="Leo and Asciidoctor"
             >previous</a> |</li>
        <li class="nav-item nav-item-0"><a href="leo_toc.html">Leo 6.7.2 documentation</a> &#187;</li>
          <li class="nav-item nav-item-1"><a href="leoandotherprograms.html" >Leo and Other Programs</a> &#187;</li>
        <li class="nav-item nav-item-this"><a href="">Leo and Emacs, including org mode</a></li> 
      </ul>
    </div>
    <div class="footer" role="contentinfo">
        &#169; Copyright 1997-2023, Edward K. Ream.
      Last updated on February 28, 2023.
      Created using <a href="https://www.sphinx-doc.org/">Sphinx</a> 5.3.0.
    </div>
  </body>
</html>